home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / iccfont.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-20  |  8.1 KB  |  314 lines
  1. /* Copyright (C) 1992, 1995 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* iccfont.c */
  20. /* Initialization support for compiled fonts */
  21. #include "string_.h"
  22. #include "ghost.h"
  23. #include "gsstruct.h"        /* for iscan.h */
  24. #include "ccfont.h"
  25. #include "errors.h"
  26. #include "ialloc.h"
  27. #include "idict.h"
  28. #include "ifont.h"
  29. #include "iname.h"
  30. #include "isave.h"        /* for ialloc_ref_array */
  31. #include "iutil.h"
  32. #include "oper.h"
  33. #include "ostack.h"        /* for iscan.h */
  34. #include "store.h"
  35. #include "stream.h"        /* for iscan.h */
  36. #include "strimpl.h"        /* for sfilter.h for picky compilers */
  37. #include "sfilter.h"        /* for iscan.h */
  38. #include "iscan.h"
  39.  
  40. /* ------ Private code ------ */
  41.  
  42. /* Forward references */
  43. private int huge cfont_ref_from_string(P3(ref *, const char *, uint));
  44.  
  45. typedef struct {
  46.     const char *str_array;
  47.     ref next;
  48. } str_enum;
  49. #define init_str_enum(sep, ksa)\
  50.   (sep)->str_array = ksa
  51. typedef struct {
  52.     cfont_dict_keys keys;
  53.     str_enum strings;
  54. } key_enum;
  55. #define init_key_enum(kep, kp, ksa)\
  56.   (kep)->keys = *kp, init_str_enum(&(kep)->strings, ksa)
  57.  
  58. /* Check for reaching the end of the keys. */
  59. #define more_keys(kep) ((kep)->keys.num_enc_keys | (kep)->keys.num_str_keys)
  60.  
  61. /* Get the next string from a string array. */
  62. /* Return 1 if it was a string, 0 if it was something else, */
  63. /* or an error code. */
  64. private int near
  65. cfont_next_string(str_enum _ss *pse)
  66. {    const byte *str = pse->str_array;
  67.     uint len = (str[0] << 8) + str[1];
  68.  
  69.     if ( len == 0xffff )
  70.       {    make_null(&pse->next);
  71.         pse->str_array = str + 2;
  72.         return 0;
  73.       }
  74.     else if ( len >= 0xff00 )
  75.       {    int code;
  76.         len = ((len & 0xff) << 8) + str[2];
  77.         code = cfont_ref_from_string(&pse->next,
  78.                          (const char *)str + 3, len);
  79.         if ( code < 0 )
  80.           return code;
  81.         pse->str_array = str + 3 + len;
  82.         return 0;
  83.       }
  84.     make_const_string(&pse->next, avm_foreign, len, str + 2);
  85.     pse->str_array = str + 2 + len;
  86.     return 1;
  87. }
  88.  
  89. /* Put the next entry into a dictionary. */
  90. /* We know that more_keys(kp) is true. */
  91. private int near
  92. cfont_put_next(ref *pdict, key_enum _ss *kep, const ref *pvalue)
  93. {    ref kname;
  94.     int code;
  95.  
  96. #define kp (&kep->keys)
  97.     if ( pdict->value.pdict == 0 )
  98.     {    /* First time, create the dictionary. */
  99.         code = dict_create(kp->num_enc_keys + kp->num_str_keys + kp->extra_slots, pdict);
  100.         if ( code < 0 )
  101.             return code;
  102.     }
  103.     if ( kp->num_enc_keys )
  104.     {    const charindex *skp = kp->enc_keys++;
  105.         code = array_get(®istered_Encoding(skp->encx), (long)(skp->charx), &kname);
  106.         kp->num_enc_keys--;
  107.     }
  108.     else        /* must have kp->num_str_keys != 0 */
  109.     {    code = cfont_next_string(&kep->strings);
  110.         if ( code != 1 )
  111.           return (code < 0 ? code : gs_note_error(e_Fatal));
  112.         code = name_ref(kep->strings.next.value.const_bytes,
  113.                 r_size(&kep->strings.next), &kname, 0);
  114.         kp->num_str_keys--;
  115.     }
  116.     if ( code < 0 )
  117.       return code;
  118.     return dict_put(pdict, &kname, pvalue);
  119. #undef kp
  120. }
  121.  
  122. /* ------ Routines called from compiled font initialization ------ */
  123.  
  124. /* Create a dictionary with general ref values. */
  125. private int huge
  126. cfont_ref_dict_create(ref *pdict, const cfont_dict_keys *kp,
  127.   cfont_string_array ksa, const ref *values)
  128. {    key_enum kenum;
  129.     const ref *vp = values;
  130.     init_key_enum(&kenum, kp, ksa);
  131.     pdict->value.pdict = 0;
  132.     while ( more_keys(&kenum) )
  133.     {    const ref *pvalue = vp++;
  134.         int code = cfont_put_next(pdict, &kenum, pvalue);
  135.         if ( code < 0 ) return code;
  136.     }
  137.     return 0;
  138. }
  139.  
  140. /* Create a dictionary with string/null values. */
  141. private int huge
  142. cfont_string_dict_create(ref *pdict, const cfont_dict_keys *kp,
  143.   cfont_string_array ksa, cfont_string_array kva)
  144. {    key_enum kenum;
  145.     str_enum senum;
  146.     uint attrs = kp->value_attrs;
  147.     init_key_enum(&kenum, kp, ksa);
  148.     init_str_enum(&senum, kva);
  149.     pdict->value.pdict = 0;
  150.     while ( more_keys(&kenum) )
  151.     {    int code =  cfont_next_string(&senum);
  152.         switch ( code )
  153.           {
  154.           default:    /* error */
  155.             return code;
  156.           case 1:    /* string */
  157.             r_set_attrs(&senum.next, attrs);
  158.           case 0:    /* other */
  159.             ;
  160.           }
  161.         code = cfont_put_next(pdict, &kenum, &senum.next);
  162.         if ( code < 0 ) return code;
  163.     }
  164.     return 0;
  165. }
  166.  
  167. /* Create a dictionary with number values. */
  168. private int huge
  169. cfont_num_dict_create(ref *pdict, const cfont_dict_keys *kp,
  170.   cfont_string_array ksa, const ref *values, const char *lengths)
  171. {    key_enum kenum;
  172.     const ref *vp = values;
  173.     const char *lp = lengths;
  174.     ref vnum;
  175.  
  176.     init_key_enum(&kenum, kp, ksa);
  177.     pdict->value.pdict = 0;
  178.     while ( more_keys(&kenum) )
  179.     {    int len = (lp == 0 ? 0 : *lp++);
  180.         int code;
  181.  
  182.         if ( len == 0 )
  183.           vnum = *vp++;
  184.         else
  185.           {    --len;
  186.             make_const_array(&vnum, avm_foreign | a_readonly, len, vp);
  187.             vp += len;
  188.           }
  189.         code = cfont_put_next(pdict, &kenum, &vnum);
  190.         if ( code < 0 ) return code;
  191.     }
  192.     return 0;
  193. }
  194.  
  195. /* Create an array with name values. */
  196. private int huge
  197. cfont_name_array_create(ref *parray, cfont_string_array ksa, int size)
  198. {    int code = ialloc_ref_array(parray, a_readonly, size,
  199.                     "cfont_name_array_create");
  200.     ref *aptr = parray->value.refs;
  201.     int i;
  202.     str_enum senum;
  203.  
  204.     if ( code < 0 ) return code;
  205.     init_str_enum(&senum, ksa);
  206.     for ( i = 0; i < size; i++, aptr++ )
  207.     {    ref nref;
  208.         int code = cfont_next_string(&senum);
  209.         if ( code != 1 )
  210.           return (code < 0 ? code : gs_note_error(e_Fatal));
  211.         code = name_ref(senum.next.value.const_bytes,
  212.                 r_size(&senum.next), &nref, 0);
  213.         if ( code < 0 )
  214.           return code;
  215.         ref_assign_new(aptr, &nref);
  216.     }
  217.     return 0;
  218. }
  219.  
  220. /* Create an array with string/null values. */
  221. private int huge
  222. cfont_string_array_create(ref *parray, cfont_string_array ksa,
  223.   int size, uint attrs)
  224. {    int code = ialloc_ref_array(parray, a_readonly, size,
  225.                     "cfont_string_array_create");
  226.     ref *aptr = parray->value.refs;
  227.     int i;
  228.     str_enum senum;
  229.  
  230.     if ( code < 0 ) return code;
  231.     init_str_enum(&senum, ksa);
  232.     for ( i = 0; i < size; i++, aptr++ )
  233.     {    int code =  cfont_next_string(&senum);
  234.         switch ( code )
  235.           {
  236.           default:    /* error */
  237.             return code;
  238.           case 1:    /* string */
  239.             r_set_attrs(&senum.next, attrs);
  240.           case 0:    /* other */
  241.             ;
  242.           }
  243.         ref_mark_new(&senum.next);
  244.         *aptr = senum.next;
  245.     }
  246.     return 0;
  247. }
  248.  
  249. /* Create a name. */
  250. private int huge
  251. cfont_name_create(ref *pnref, const char *str)
  252. {    return name_ref((const byte *)str, strlen(str), pnref, 0);
  253. }
  254.  
  255. /* Create an object by parsing a string. */
  256. private int huge
  257. cfont_ref_from_string(ref *pref, const char *str, uint len)
  258. {    scanner_state sstate;
  259.     stream s;
  260.     int code;
  261.  
  262.     scanner_state_init(&sstate, false);
  263.     sread_string(&s, (const byte *)str, len);
  264.     code = scan_token(&s, pref, &sstate);
  265.     return (code <= 0 ? code : gs_note_error(e_Fatal));
  266. }
  267.  
  268. /* ------ Initialization ------ */
  269.  
  270. /* Procedure vector passed to font initialization procedures. */
  271. private const cfont_procs ccfont_procs = {
  272.     cfont_ref_dict_create,
  273.     cfont_string_dict_create,
  274.     cfont_num_dict_create,
  275.     cfont_name_array_create,
  276.     cfont_string_array_create,
  277.     cfont_name_create,
  278.     cfont_ref_from_string
  279. };
  280.  
  281. /* null    .getccfont    <number-of-fonts> */
  282. /* <int>   .getccfont    <font-object> */
  283. private int
  284. zgetccfont(register os_ptr op)
  285. {
  286.   int code;
  287.   ccfont_fproc **fprocs;
  288.   int nfonts;
  289.   int index;
  290.  
  291.   code = ccfont_fprocs (&nfonts, &fprocs);
  292.   if ( code != ccfont_version )
  293.     return_error(e_invalidfont);
  294.  
  295.   if ( r_has_type(op, t_null) )
  296.   {
  297.     make_int(op, nfonts);
  298.     return 0;
  299.   }
  300.  
  301.   check_type(*op, t_integer);
  302.   index = op->value.intval;
  303.   if ( index < 0 || index >= nfonts )
  304.     return_error(e_rangecheck);
  305.  
  306.   return (*fprocs[index])(&ccfont_procs, op);
  307. }
  308.  
  309. /* Operator table initialization */
  310.  
  311. BEGIN_OP_DEFS(ccfonts_op_defs) {
  312.   {"0.getccfont", zgetccfont},
  313. END_OP_DEFS(0) }
  314.